const Protocol = require('../models/protocol');
const ProtocolElement = require('../models/protocolElement');

// 创建协议
exports.createProtocol = async (req, res) => {
  try {
    const { name, description, categoryId, isPublic } = req.body;
    const userId = req.user.id;
    
    // 验证必填字段
    if (!name) {
      return res.status(400).json({ message: '协议名称为必填项' });
    }
    
    // 创建新协议
    const newProtocol = await Protocol.create(
      name, 
      description || '', 
      userId, 
      categoryId || null, 
      isPublic || false
    );
    
    // 返回成功消息
    res.status(201).json({
      message: '协议创建成功',
      protocol: newProtocol
    });
  } catch (error) {
    console.error('创建协议失败:', error);
    res.status(500).json({ message: '服务器错误，创建协议失败' });
  }
};

// 获取用户的所有协议
exports.getUserProtocols = async (req, res) => {
  try {
    const userId = req.user.id;
    
    // 获取协议列表
    const protocols = await Protocol.findByUserId(userId);
    
    // 返回协议列表
    res.status(200).json({
      protocols
    });
  } catch (error) {
    console.error('获取协议失败:', error);
    res.status(500).json({ message: '服务器错误，获取协议失败' });
  }
};

// 获取分类下的所有协议
exports.getProtocolsByCategory = async (req, res) => {
  try {
    const categoryId = req.params.categoryId;
    const userId = req.user.id;
    
    // 获取协议列表
    const protocols = await Protocol.findByCategoryId(categoryId, userId);
    
    // 返回协议列表
    res.status(200).json({
      protocols
    });
  } catch (error) {
    console.error('获取协议失败:', error);
    res.status(500).json({ message: '服务器错误，获取协议失败' });
  }
};

// 获取协议详情
exports.getProtocolById = async (req, res) => {
  try {
    const protocolId = req.params.id;
    const userId = req.user.id;
    
    // 查找协议
    const protocol = await Protocol.findById(protocolId, userId);
    if (!protocol) {
      return res.status(404).json({ message: '协议不存在或无权访问' });
    }
    
    // 获取协议元素
    const elements = await Protocol.getElements(protocolId);
    
    // 返回协议详情
    res.status(200).json({
      protocol,
      elements
    });
  } catch (error) {
    console.error('获取协议详情失败:', error);
    res.status(500).json({ message: '服务器错误，获取协议详情失败' });
  }
};

// 更新协议
exports.updateProtocol = async (req, res) => {
  try {
    const protocolId = req.params.id;
    const { name, description, categoryId, isPublic } = req.body;
    const userId = req.user.id;
    
    // 查找协议
    const protocol = await Protocol.findById(protocolId, userId);
    if (!protocol) {
      return res.status(404).json({ message: '协议不存在或无权访问' });
    }
    
    // 检查权限
    if (protocol.user_id !== userId) {
      return res.status(403).json({ message: '无权修改此协议' });
    }
    
    // 验证必填字段
    if (!name) {
      return res.status(400).json({ message: '协议名称为必填项' });
    }
    
    // 更新协议
    const updatedProtocol = await Protocol.update(
      protocolId,
      name,
      description || protocol.description,
      categoryId !== undefined ? categoryId : protocol.category_id,
      isPublic !== undefined ? isPublic : protocol.is_public
    );
    
    // 返回成功消息
    res.status(200).json({
      message: '协议更新成功',
      protocol: updatedProtocol
    });
  } catch (error) {
    console.error('更新协议失败:', error);
    res.status(500).json({ message: '服务器错误，更新协议失败' });
  }
};

// 删除协议
exports.deleteProtocol = async (req, res) => {
  try {
    const protocolId = req.params.id;
    const userId = req.user.id;
    
    // 查找协议
    const protocol = await Protocol.findById(protocolId, userId);
    if (!protocol) {
      return res.status(404).json({ message: '协议不存在或无权访问' });
    }
    
    // 检查权限
    if (protocol.user_id !== userId) {
      return res.status(403).json({ message: '无权删除此协议' });
    }
    
    // 删除协议
    await Protocol.delete(protocolId);
    
    // 返回成功消息
    res.status(200).json({
      message: '协议删除成功'
    });
  } catch (error) {
    console.error('删除协议失败:', error);
    res.status(500).json({ message: '服务器错误，删除协议失败' });
  }
};

// 添加协议元素
exports.addProtocolElement = async (req, res) => {
  try {
    const protocolId = req.params.id;
    const { name, enName, elementType, position, value, dataType, calcType } = req.body;
    const userId = req.user.id;
    
    // 查找协议
    const protocol = await Protocol.findById(protocolId, userId);
    if (!protocol) {
      return res.status(404).json({ message: '协议不存在或无权访问' });
    }
    
    // 检查权限
    if (protocol.user_id !== userId) {
      return res.status(403).json({ message: '无权修改此协议' });
    }
    
    // 验证必填字段
    if (!name || !enName || !elementType) {
      return res.status(400).json({ message: '元素名称、英文名称和类型为必填项' });
    }
    
    // 创建元素
    const element = await ProtocolElement.create(
      protocolId,
      name,
      enName,
      elementType,
      position || 0
    );
    
    // 根据元素类型添加属性
    if (elementType === 'fixed' && value) {
      await ProtocolElement.addFixedProperties(element.id, value);
    } else if (elementType === 'normal' && dataType) {
      await ProtocolElement.addNormalProperties(element.id, dataType);
    } else if (elementType === 'auto' && calcType) {
      await ProtocolElement.addAutoProperties(element.id, calcType);
    }
    
    // 返回成功消息
    res.status(201).json({
      message: '元素添加成功',
      element
    });
  } catch (error) {
    console.error('添加元素失败:', error);
    res.status(500).json({ message: '服务器错误，添加元素失败' });
  }
};

// 更新协议元素
exports.updateProtocolElement = async (req, res) => {
  try {
    const elementId = req.params.elementId;
    const { name, enName, value, dataType, calcType, position } = req.body;
    
    // 更新元素基本信息
    if (name && enName) {
      await ProtocolElement.update(elementId, name, enName);
    }
    
    // 更新元素位置
    if (position !== undefined) {
      await ProtocolElement.updatePosition(elementId, position);
    }
    
    // 更新元素属性
    if (value !== undefined) {
      await ProtocolElement.updateFixedProperties(elementId, value);
    }
    
    if (dataType) {
      await ProtocolElement.updateNormalProperties(elementId, dataType);
    }
    
    if (calcType) {
      await ProtocolElement.updateAutoProperties(elementId, calcType);
    }
    
    // 返回成功消息
    res.status(200).json({
      message: '元素更新成功'
    });
  } catch (error) {
    console.error('更新元素失败:', error);
    res.status(500).json({ message: '服务器错误，更新元素失败' });
  }
};

// 删除协议元素
exports.deleteProtocolElement = async (req, res) => {
  try {
    const elementId = req.params.elementId;
    
    // 删除元素
    await ProtocolElement.delete(elementId);
    
    // 返回成功消息
    res.status(200).json({
      message: '元素删除成功'
    });
  } catch (error) {
    console.error('删除元素失败:', error);
    res.status(500).json({ message: '服务器错误，删除元素失败' });
  }
};

// 获取元素库
exports.getElementLibrary = async (req, res) => {
  try {
    const userId = req.user.id;
    
    // 获取元素库
    const elements = await ProtocolElement.getElementLibrary(userId);
    
    // 返回元素库
    res.status(200).json({
      elements
    });
  } catch (error) {
    console.error('获取元素库失败:', error);
    res.status(500).json({ message: '服务器错误，获取元素库失败' });
  }
};
